package monster.flight.admin.manager.imp.xtgl;
import java.util.ArrayList;
import java.util.Map;

import java.util.List;

import monster.comm.exception.InvalidParameterException;
import monster.comm.exception.UniqueNeedException;
import monster.comm.key.Key;
import monster.comm.log.ILog;
import monster.comm.log.LogService;
import monster.comm.util.Tool;
import monster.flight.admin.manager.service.xtgl.DictService;
import monster.flight.admin.querydao.xtgl.Dict_queryDAO;
import monster.flight.admin.vo.xtgl.Dict_And_detailVO;
import monster.flight.comm.entity.dao.Xt_dictDAO;
import monster.flight.comm.entity.dao.Xt_dict_detailDAO;
import monster.flight.comm.entity.vo.Xt_dict;
import monster.flight.comm.entity.vo.Xt_dict_detail;
import monster.flight.comm.util.KeyConstant;

/**
 * 
* 创建信息=============
* 类名: monster.flight.admin.manager.imp.xtgl.DictServiceImp
* 类作用描述: 数据字典的实现类
* 创建人： jzk 
* 创建时间： 2013-1-9 上午11:13:49
* 修改信息1=============
* 修改类型:     //1.修改bug 2.业务变化修改
* 修改描述: 
* 修改人：  
* 修改时间：
 */
public class DictServiceImp  implements DictService{
  private static ILog log = LogService.getLog(DictService.class);
  private Dict_queryDAO dict_queryDAO;//数据字典查询dao
  private Xt_dictDAO xt_dictDAO;
  private Xt_dict_detailDAO xt_dict_detailDAO;
public Xt_dict_detailDAO getXt_dict_detailDAO() {
	return xt_dict_detailDAO;
}


public void setXt_dict_detailDAO(Xt_dict_detailDAO xt_dict_detailDAO) {
	this.xt_dict_detailDAO = xt_dict_detailDAO;
}


public Dict_queryDAO getDict_queryDAO() {
	return dict_queryDAO;
}


public void setDict_queryDAO(Dict_queryDAO dictQueryDAO) {
	dict_queryDAO = dictQueryDAO;
}


public Xt_dictDAO getXt_dictDAO() {
	return xt_dictDAO;
}


public void setXt_dictDAO(Xt_dictDAO xt_dictDAO) {
	this.xt_dictDAO = xt_dictDAO;
}


/**
*@Description: 得到所有数据字典及明细
*@return  
*@return List     Dict_And_detailVO的list
*@throws
 */
public List<Dict_And_detailVO> getDictAndDetail(){
	return dict_queryDAO.getDictAndDetail();
}


/**
*@author lzy
*@Description: 根据PO里的过滤条件，得到所有数据字典
*@param   Xt_dict 
*@return List     Dict_And_detailVO的list
*@throws Exception
 */
public List<Xt_dict> selectPage(Map<String,Object> map)
		throws Exception {
	List<Xt_dict> list = new ArrayList<Xt_dict>();
	
	Tool.NullException(map, "map不能为null");
	Tool.NullException(map.get("condition"), "condition不能为null");
	Tool.NullException(map.get("order"), "order不能为null");
	list = xt_dictDAO.selectPage_DictListByPo(map);
	return list;
}


/**
*@author lzy
*@Description: 添加数据字典
*@param   Xt_dict 
*@return void
*@throws Exception
 */
public void insertDict(Xt_dict po) throws Exception {
	Tool.NullException(po, "po 不能为null");
	po.setDict_type("0");//非树形
	
	Tool.NullException("".equals(po.getDict_code()), "dict_code 不能为null");
	//如果DICT_CODE存在>0,那么不能保存这个DICT_CODE
	if(xt_dictDAO.dict_codeExist(po.getDict_code())>0){
		Tool.UniqueException("DICT_CODE，已经存在");
	}else{//保存
		int key = Key.getKey(KeyConstant.XT_KEY_SN);
		po.setDict_sn(String.valueOf(key));
		po.setDict_type("0");
		xt_dictDAO.insert(po);
	}
	
}


/**
*@author lzy
*@Description: 根据主键更新数据字典
*@param   Xt_dict 
*@return void
*@throws Exception
 */
public void updateDictByKey(Xt_dict po) throws Exception {
	
	Tool.NullException(po, "po 不能为null");
	String temp_dict_code=po.getTemp_dict_code();
	String dict_code=po.getDict_code();
	
	Tool.NullException(dict_code, "dict_code 不能为null");
	Tool.NullException(po.getDict_sn(), "主键 不能为null");
	
	//如果两个不相等则表示用户修改了编码
	if(!temp_dict_code.equals(dict_code)){
		//如果DICT_CODE存在>0,那么不能保存这个DICT_CODE
		if(xt_dictDAO.dict_codeExist(po.getDict_code())>0){
			Tool.UniqueException("DICT_CODE，已经存在不能保存");
			
		}else{				
			xt_dictDAO.update(po);
			//修改字典选项的字典编码
			Xt_dict_detail detailpo= new Xt_dict_detail();
			detailpo.setDict_code(dict_code);
			detailpo.setDict_sn(po.getDict_sn());
			xt_dict_detailDAO.update(detailpo);//修改字典选项的字典编码
			po.setTemp_dict_code(dict_code);//同步字典编码
			
		}
	}else{
		xt_dictDAO.update(po);
	}
	
}


/**
 * 删除数据字典
 * @param Xt_dict
 * @throws Exception
 */
public void deteleDictByKey(Xt_dict po) throws Exception {
	
	Tool.NullException(po, "po 不能为null");
	Tool.NullException(po.getDict_sn(), "Dict_sn 不能为null");
	xt_dict_detailDAO.deleteDictDetalByDict_SN(po.getDict_sn());//xt_dict_detailDAO.//先删除字典明细(pks, "dict_sn");
	xt_dictDAO.delete(po);//删除数据字典
	
	
}


/**
 * @author lzy
 * @Description:分页用
 * @param po
 * @return
 * @throws Exception
 */
public int getRowCount(Xt_dict po) throws Exception {
	int ret =0;
	
	Tool.NullException(po, "po 不能为null");
	ret = xt_dictDAO.getRowCount(po);
	return ret;
}


/**
 * 根据主键得到一条数据
 * @param key
 * @return
 * @throws Exception
 */
public Xt_dict getPoByKey(String key) throws Exception {
	Tool.NullException(key, "主键不能为null");
	return xt_dictDAO.getPoByKey(key);
}


/**
 * @author lzy
 * @Description:判断数据字典编码是否存在
 * @param xt_dict
 * @return true存在 false不存在
 */
public boolean dict_codeExist(String dict_code,String old_dict_code) throws Exception {
	Tool.NullException(dict_code, "dict_code不能为null");
	//Tool.NullException(old_dict_code, "old_dict_code不能为null");
	boolean ret = false;
	//dict_code发生变化才校验
	if(!dict_code.equals(old_dict_code)){
		int i=xt_dictDAO.dict_codeExist(dict_code);	
		ret =i>0?true:false;
	}	
	return ret;
}
  

/**
*@author lzy
*@Description: 根据DICT_SN查询数据字典明细  Xt_dict_detail.DICT_SN不能为空
*@param   Xt_dict_detail 
*@return void
*@throws Exception
 */
public List<Xt_dict_detail> getDictDetailList(Xt_dict_detail po)
		throws Exception {
	List<Xt_dict_detail> list = new ArrayList<Xt_dict_detail>();
	
	Tool.NullException(po, "po 不能为null");
	Tool.NullException(po.getDict_sn(), "外键dict_sn不能为空");
	list=xt_dict_detailDAO.getPoByParams(po);
	
	return list;
}

/**
*@author lzy
*@Description: 添加数据字典明细
*@param   Xt_dict_detail 
*@return void
*@throws Exception
 */
public void insertDictDetail(Xt_dict_detail po) throws Exception {
	
	Tool.NullException(po, "po 不能为null");
	Tool.NullException(po.getDict_code(), "dict_code 不能为null");
	Tool.NullException(po.getDict_sn(), "Dict_sn 不能为null");
	Tool.NullException(po.getLevel_index(), "Level_index 不能为null");
	Tool.NullException(po.getParent_code(), "Parent_code 不能为null");
	Tool.NullException(po.getOption_id(), "option_id 不能为null");
	
	if(xt_dict_detailDAO.validateOption_idOnly(po)>0){//校验选项编码唯一性,>0表示option_id数据已存在
		Tool.UniqueException("option_id已存在");
	}else{
		po.setIs_leaf("1");//默认本节点为叶子节点			
		po.setIs_move("0");//否删除
		int key = Key.getKey(KeyConstant.XT_KEY_SN);
		po.setOption_sn(String.valueOf(key));
		
		if("0".equals(po.getParent_code())){//如果为0表示是第一层
			po.setFomcat("."+key+".");
		}
		else{//如果不是第一层格式码
			
			Tool.NullException(po.getFomcat(), "父节点Fomcat 不能为空");
			po.setFomcat(po.getFomcat()+key+".");//父节点dna的FOMCAT.本节点的key.
		}			
		//获取层次
		int level=Integer.parseInt(po.getLevel_index())+1;			
		po.setLevel_index(String.valueOf(level));
		xt_dict_detailDAO.insert(po);//添加数据
		
		//如果本节点不是跟节点
		if(!"0".equals(po.getParent_code())){
			xt_dict_detailDAO.updtateParentLeaf(po.getParent_code());//修改父节点为非叶子节点
			xt_dictDAO.updateDictTypeTree(po.getDict_sn());//修改字典类型为树形					
		}
	}	
	
}

/**
*@author lzy
*@Description: 根据主键更新数据字典明细 Xt_dict_detail.DICT_SN不能为空
*@param   Xt_dict_detail 
*@return void
*@throws Exception
 */
public void updateDictDetailByKey(Xt_dict_detail po)throws Exception {		
	Tool.NullException(po, "po 不能为null");
	String option_sn=po.getOption_sn();
	String option_id=po.getOption_id();
	String temp_option_id=po.getOption_id_temp();
	Tool.NullException(option_sn, "option_sn 不能为null");
	Tool.NullException(temp_option_id, "option_id 不能为null");
	Tool.NullException(option_id, "option_id 不能为null");		
	
	//如果选项编码做了改变，需要校验其唯一性
	if(!option_id.equals(temp_option_id)){
		if(xt_dict_detailDAO.validateOption_idOnly(po)>0){//校验选项编码唯一性,>0表示option_id数据已存在
			Tool.UniqueException("option_id已存在");
		}else{
			xt_dict_detailDAO.update(po);
			po.setOption_id_temp(option_id);//同步字典选项编码
		}
	}else{
		xt_dict_detailDAO.update(po);
	}
	
}

/**
*@author lzy
*@Description: 根据主键删除数据字典明细 Xt_dict_detail.option_sn不能为空
*@param   Xt_dict_detail 
*@return void
*@throws Exception
 */
public void deleteDictDetailByFomcat(Xt_dict_detail po)throws  Exception {
	Tool.NullException(po, "po 不能为null");
	Tool.NullException(po.getFomcat(), "Fomcat 不能为null");
	xt_dict_detailDAO.deleteByFomcat(po.getFomcat());
}

/**
 * 根据外键dict_sn删除数据
 * @param dict_sn
 * @throws Exception
 */
public void deleteDictDetalByDict_SN(String dict_sn)throws  Exception {
	Tool.NullException(dict_sn, "dict_sn不能为null");
	xt_dict_detailDAO.deleteDictDetalByDict_SN(dict_sn);
	
}

/**
*@Description: 根据主键返回po
*@param id
*@return Xt_dict_detail
*@throws Exception
*/
public Xt_dict_detail getPoByID(String option_sn) throws Exception {
	Tool.NullException(option_sn, "option_sn不能为null");		
	return xt_dict_detailDAO.getPoByID(option_sn);
}

/**
  * 校验选项编码唯一性
  * @param po
  * @return true唯一  false不唯一
  */
public boolean validateOption_idOnly(Xt_dict_detail po)throws Exception {
	Tool.NullException(po, "po 不能为null");
	String dict_sn=po.getDict_sn();
	String option_id=po.getOption_id();
	String option_id_temp=po.getOption_id_temp();
	Tool.NullException(dict_sn, "dict_sn 不能为null");
	Tool.NullException(option_id, "option_id 不能为null");
	//Tool.NullException(option_id_temp,"option_id_temp 不能为null");
	boolean ret=true;
	if(!option_id.equals(option_id_temp)){
		int i=xt_dict_detailDAO.validateOption_idOnly(po);
		ret=i>0?false:true;
	}
	
	return ret;
}
}
